Cream of the Crop 12/Cream of the Crop 12 (Part II)/Cream of the Crop 12 (Part II).iso/OS2/LW32.ZIP/TAP11.ZIP/tapsamp.c

C/C++ Source or Header | 1995-05-04 | 7.7 KB | 301 lines

//
// TAP
// Sample Application
// Revision 1.10
//
//  1/5/95    First created
//
#define INCL_DOS
#include <os2.h>
#include <stdio.h>
#include <string.h>
#include "tapapp.h"

//
// void RegisterSampleApplication(char *szProgramPath);
//
// Registers the TAP application so that any
// TAP server on the system can find it. This function
// need only be called once.
//
// Parameters:
// szProgramPath
//   Fully qualified path to the executable. Must include .EXE
//   extension.
//   EX: C:\TAPSAMP.EXE
//
// Returns: Nothing
//
void RegisterSampleApplication(char *szProgramPath)
{
TAPAPPENTRY TapAppEntry;

    // Fill in information structure
    TapAppEntry . cb = sizeof(TAPAPPENTRY);

    // Each TAP application can have a description
    // up to 256 characters and 6 lines long
    strcpy(TapAppEntry . szDescription,
                "This is a sample TAP application "      //
                "used for development purposes.\n\r\n\r" //
                "Each file encountered is displayed "    //
                "along with its data as the transfer "   //
                "progresses." );

    // Any extra parameters needed to be passed go here
    strcpy(TapAppEntry . szParams, "");

    strcpy(TapAppEntry . szProgram,
                szProgramPath);

   // No extensions for this application
   TapAppEntry . ulExtensions = 0;

    //
    // Register this TAP application
    //
    // This registration can be removed later with
    // DeRegisterApplication_TAP
    //
    if (!RegisterApplication_TAP("TAP Development Sample",
                                             &TapAppEntry))
        printf("Error : Could not register TAP application\n");
    else
        printf("Application registered successfully\n");

}

//
// void ProcessData(HFILE TAPFile,
//                          long lCurrentFileSize);
//
// This function is called when new data needs to
// be processed by the TAP application. This is the
// place where a GIF viewer might interpret new data
// and display it as a picture on the screen.
//
// The code here is only a sample of what can be done,
// and if you are basing your TAP application on this
// source it's best if you replace this entire function.
//
// Parameters:
// TAPFile
//   OS/2 file handle (for use with Dosxxx commands)
//   that has read-only access to the file being
//   transferred.
// lCurrentFileSize
//   The current file size. Attempts to read past
//   past this point will normally fail.
//
// Returns: Nothing
//
void ProcessData(HFILE TAPFile,
                        long lCurrentFileSize)
{
unsigned char szBuf[10];
ULONG BytesRead;
APIRET rc = 0;
int cnter;

    // Seek to the end of the file,
    // minus ten bytes
    rc |=
        DosSetFilePtr(TAPFile,
            lCurrentFileSize - 10,
            FILE_BEGIN,
            &BytesRead);

    // Read those ten last bytes
    rc |=
        DosRead(TAPFile,
          szBuf,
          10,
          &BytesRead);

    // If we didn't read ten bytes,
    // there was an error
    if (BytesRead<10)
            rc = 1;

    if (rc)
        // Something went wrong
        printf("%8d : error reading\n", lCurrentFileSize);
    else
    {
        // Print current file size
        printf("%8d Data :", lCurrentFileSize);

        // And then display last 10 bytes of data
        // in hexidecimal format
        for (cnter=0; cnter<10; cnter++)
            printf(" %2.2X", szBuf[cnter]);

        // Carriage return: don't fill up the
        // screen w
        printf("%c",13);
        // Need to flush if our compiler has buffered output
        // (Note that buffered output is only flushed for LF, not CR !)
        fflush (stdout);
    }
}

//
// int main(int argc, char **argv);
//
// Main TAP function.
//
// This function registers the TAP
// application, then attempts to start
// a TAP session.
//
// The standard structure of a TAP
// application must be:
//
// Initialize();
// while (NextFile)
//    {
//        OpenFile();
//    while (MoreData)
//            ProcessData();  <-- Here's where your
//    ProcessData();     <-- application does its work
//        CloseFile();
//  }
// DeInitialize();
//
// Parameters:
// It's important to have the argc
// and argv information around because
// TAP initialize must parse the
// command line.
//
// Returns: Return value unimportant to TAP
//
int main(int argc, char **argv)
{
PTAPAPPINFO pTapAppInfo;      // TAP instance data structure
                                        // (You needn't worry about this)

    //
    // Attempt to register this application so
    // TAP servers can see it.
    //
    // The full path, as below, must be passed.
    // The program name is kept in argv[0] (ANSI standard)
    // but some compilers handle this differently.
    //
    // Borland C will give you the fully qualified path
    // while CSet will give you only the application name
    // typed at the command prompt.
    //
    // If you're one of those lucky people who are only
    // passed the file name you can construct a fully qualified
    // path name by calling DosQueryPathInfo with 2nd parameter
    // of FIL_QUERYFULLNAME.
    //

    // Les: I suggest you *always* call DosQueryPathInfo even though
   //      Borland C already gives you the full name: DosQueryPathInfo
   //      makes sure that the returned path is valid, etc. etc...

    {  CHAR szFullPath[CCHMAXPATH];
        strcpy (szFullPath, argv[0]);
        if (!strchr (szFullPath, '.'))
            strcat (szFullPath, ".EXE");
        DosQueryPathInfo (szFullPath, FIL_QUERYFULLNAME, szFullPath, sizeof (szFullPath));
        RegisterSampleApplication(szFullPath);
        }

    // Initialize the TAP subsystem
    pTapAppInfo = InitializeApplication_TAP(argc, argv);

    // On success we get a non-NULL pointer back
    if (pTapAppInfo)
    {
        CHAR szBuffer[32];
        printf("Application initialized successfully\n\n");

        QueryServerVersion_TAP (pTapAppInfo, szBuffer, sizeof (szBuffer));

        printf ("Server Version: %s\n", szBuffer);

        // NextFile_TAP will wait for the next file to arrive.
        // If no more files are pending, NextFile_TAP will
        // return FALSE, otherwise TRUE
        while (NextFile_TAP(pTapAppInfo))
        {
        char szFileName[CCHMAXPATH];
        long lCompleteFileSize;
        long lCurrentFileSize;
        HFILE TAPFile;

            // Get the fully qualified name of the file
            QueryFileName_TAP(pTapAppInfo, szFileName);

            // Get the complete size of the file
            // -1 (TAP_SIZE_UNKNOWN) if we don't know it
            lCompleteFileSize = QueryCompleteSize_TAP(pTapAppInfo);

            // Display status
            printf("File : %s of size %d\n",
                        szFileName,
                        lCompleteFileSize);

            // Open the TAP file. The file must be opened
            // using this TAP API so file sharing can take place
            if (!OpenFile_TAP(pTapAppInfo, &TAPFile))
                printf("Error opening file!\n");

            // MoreData_TAP waits until new data has been
            // written to the file.
            //
            // If the end of file has been reached, or
            // the transfer has been cancelled MoreData_TAP
            // returns FALSE, otherwise TRUE.
            while (MoreData_TAP(pTapAppInfo))
            {
                // Get the current file size
                // This will always be different from the last time
                lCurrentFileSize = QueryCurrentSize_TAP(pTapAppInfo);

                // Now process any new data
                ProcessData(TAPFile,
                                lCurrentFileSize);
            }

            // Determine complete file length,
            // which may have changed if the
            // file was cut short
            DosSetFilePtr(TAPFile,
                                0,
                                FILE_END,
                                (PULONG)(PVOID)&(lCompleteFileSize));

            // There may be some data we didn't
            // finish processing. Process all
            // data before opening a new file
            ProcessData(TAPFile,
                            lCompleteFileSize);

            printf("\nFile complete at %d bytes\n\n", lCompleteFileSize);

            // Close the file: processing complete
            CloseFile_TAP(pTapAppInfo, TAPFile);
        }

        // We've dropped out of the main loop
        // so there are no more files
        printf("Transfer complete.\n");

        // Deinitialize the TAP application
        DeInitializeApplication_TAP(pTapAppInfo);
    }
     else
    {
        printf("Error : Cannot initialize TAP application\n\n");
        printf("Start this application from a TAP server\n");
    }

    return 0;
}